// $ANTLR 3.1.2 D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g 2010-03-31 13:06:43

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162
namespace  ProjectBase.Tools.Wiki

{

using System.Text;
using System.Collections.Generic;


using System;
using Antlr.Runtime;
using Antlr.Runtime.Tree;using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;



public partial class WikiTree : TreeParser
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"CODE_BEGIN", 
		"CODE_END", 
		"HTML_BEGIN", 
		"HTML_END", 
		"XML_BEGIN", 
		"XML_END", 
		"PRE_BEGIN", 
		"PRE_END", 
		"BQ_BEGIN", 
		"BQ_END", 
		"LI_BEGIN", 
		"LI_END", 
		"NUM_BEGIN", 
		"NUM_END", 
		"NEWLINE", 
		"WS", 
		"COMMENT", 
		"QUOTED", 
		"LTSIGN", 
		"SLASH", 
		"LT", 
		"GTSIGN", 
		"GT", 
		"ESCAPE", 
		"A", 
		"NAME", 
		"IMG", 
		"CLOSE", 
		"VLINE", 
		"COLON", 
		"NOCONTROL", 
		"ATTR_TEXT", 
		"ATTR_HEIGHT", 
		"ATTR_WIDTH", 
		"ATTR_FLOAT", 
		"STYLES", 
		"COLORS", 
		"INLINE_BEGIN", 
		"EXCLAM", 
		"HASH", 
		"AMPR", 
		"LEFT", 
		"RIGHT", 
		"DOT", 
		"SEMI", 
		"EQUAL", 
		"QUEST", 
		"LCB", 
		"RCB", 
		"DIGIT", 
		"UPPER", 
		"LOWER", 
		"NOLEADING", 
		"UNICODREST", 
		"LETTER", 
		"ENCODED", 
		"SYMBOLS", 
		"CSHARP_BASE", 
		"CSHARP_TYPES", 
		"CSHARP_FLOW", 
		"CSHARP_SPECIAL", 
		"HTML_BASE", 
		"IBTOKEN", 
		"WORD", 
		"ELEMENT", 
		"NAME_ELEMENT", 
		"A_ELEMENT", 
		"IMG_ELEMENT", 
		"CODE", 
		"XML", 
		"HTML", 
		"INLINE", 
		"TAG", 
		"LIST", 
		"NUMERIC"
    };

    public const int COLORS = 40;
    public const int LT = 24;
    public const int LI_BEGIN = 14;
    public const int INLINE_BEGIN = 41;
    public const int QUOTED = 21;
    public const int LETTER = 58;
    public const int HTML_BASE = 65;
    public const int ATTR_TEXT = 35;
    public const int STYLES = 39;
    public const int CSHARP_TYPES = 62;
    public const int CSHARP_SPECIAL = 64;
    public const int CSHARP_FLOW = 63;
    public const int HTML = 74;
    public const int RCB = 52;
    public const int EOF = -1;
    public const int IBTOKEN = 66;
    public const int QUEST = 50;
    public const int CODE = 72;
    public const int WORD = 67;
    public const int HTML_BEGIN = 6;
    public const int NUM_BEGIN = 16;
    public const int CODE_END = 5;
    public const int NAME = 29;
    public const int SLASH = 23;
    public const int ESCAPE = 27;
    public const int LCB = 51;
    public const int LEFT = 45;
    public const int EQUAL = 49;
    public const int CSHARP_BASE = 61;
    public const int IMG_ELEMENT = 71;
    public const int ELEMENT = 68;
    public const int ATTR_WIDTH = 37;
    public const int NUM_END = 17;
    public const int DIGIT = 53;
    public const int DOT = 47;
    public const int COMMENT = 20;
    public const int NOLEADING = 56;
    public const int IMG = 30;
    public const int XML_BEGIN = 8;
    public const int UNICODREST = 57;
    public const int A = 28;
    public const int AMPR = 44;
    public const int NAME_ELEMENT = 69;
    public const int PRE_END = 11;
    public const int ENCODED = 59;
    public const int BQ_END = 13;
    public const int HASH = 43;
    public const int ATTR_FLOAT = 38;
    public const int RIGHT = 46;
    public const int CODE_BEGIN = 4;
    public const int NUMERIC = 78;
    public const int HTML_END = 7;
    public const int LIST = 77;
    public const int SEMI = 48;
    public const int NOCONTROL = 34;
    public const int TAG = 76;
    public const int COLON = 33;
    public const int LTSIGN = 22;
    public const int WS = 19;
    public const int NEWLINE = 18;
    public const int CLOSE = 31;
    public const int A_ELEMENT = 70;
    public const int EXCLAM = 42;
    public const int LI_END = 15;
    public const int XML_END = 9;
    public const int VLINE = 32;
    public const int GT = 26;
    public const int BQ_BEGIN = 12;
    public const int INLINE = 75;
    public const int LOWER = 55;
    public const int SYMBOLS = 60;
    public const int XML = 73;
    public const int ATTR_HEIGHT = 36;
    public const int UPPER = 54;
    public const int GTSIGN = 25;
    public const int PRE_BEGIN = 10;

    // delegates
    // delegators



        public WikiTree(ITreeNodeStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public WikiTree(ITreeNodeStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
        }
        
    protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

    public ITreeAdaptor TreeAdaptor
    {
        get { return this.adaptor; }
        set {
    	this.adaptor = value;
    	}
    }

    override public string[] TokenNames {
		get { return WikiTree.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g"; }
    }


    public class execute_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "execute"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:22:1: execute : ( statement )* ;
    public WikiTree.execute_return execute() // throws RecognitionException [1]
    {   
        WikiTree.execute_return retval = new WikiTree.execute_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        WikiTree.statement_return statement1 = default(WikiTree.statement_return);



        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:22:10: ( ( statement )* )
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:22:12: ( statement )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:22:12: ( statement )*
            	do 
            	{
            	    int alt1 = 2;
            	    int LA1_0 = input.LA(1);

            	    if ( (LA1_0 == NEWLINE || LA1_0 == ELEMENT || (LA1_0 >= CODE && LA1_0 <= HTML) || (LA1_0 >= LIST && LA1_0 <= NUMERIC)) )
            	    {
            	        alt1 = 1;
            	    }


            	    switch (alt1) 
            		{
            			case 1 :
            			    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:22:12: statement
            			    {
            			    	_last = (CommonTree)input.LT(1);
            			    	PushFollow(FOLLOW_statement_in_execute56);
            			    	statement1 = statement();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, statement1.Tree);

            			    }
            			    break;

            			default:
            			    goto loop1;
            	    }
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whining that label 'loop1' has no statements


            }

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "execute"

    public class statement_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "statement"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:24:1: statement : ( block | lists | NEWLINE ->);
    public WikiTree.statement_return statement() // throws RecognitionException [1]
    {   
        WikiTree.statement_return retval = new WikiTree.statement_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree NEWLINE4 = null;
        WikiTree.block_return block2 = default(WikiTree.block_return);

        WikiTree.lists_return lists3 = default(WikiTree.lists_return);


        CommonTree NEWLINE4_tree=null;
        RewriteRuleNodeStream stream_NEWLINE = new RewriteRuleNodeStream(adaptor,"token NEWLINE");

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:24:10: ( block | lists | NEWLINE ->)
            int alt2 = 3;
            switch ( input.LA(1) ) 
            {
            case ELEMENT:
            case CODE:
            case XML:
            case HTML:
            	{
                alt2 = 1;
                }
                break;
            case LIST:
            case NUMERIC:
            	{
                alt2 = 2;
                }
                break;
            case NEWLINE:
            	{
                alt2 = 3;
                }
                break;
            	default:
            	    NoViableAltException nvae_d2s0 =
            	        new NoViableAltException("", 2, 0, input);

            	    throw nvae_d2s0;
            }

            switch (alt2) 
            {
                case 1 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:24:12: block
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_block_in_statement64);
                    	block2 = block();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, block2.Tree);

                    }
                    break;
                case 2 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:24:20: lists
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_lists_in_statement68);
                    	lists3 = lists();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, lists3.Tree);

                    }
                    break;
                case 3 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:24:28: NEWLINE
                    {
                    	_last = (CommonTree)input.LT(1);
                    	NEWLINE4=(CommonTree)Match(input,NEWLINE,FOLLOW_NEWLINE_in_statement72);  
                    	stream_NEWLINE.Add(NEWLINE4);



                    	// AST REWRITE
                    	// elements:          
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 24:36: ->
                    	{
                    	    root_0 = null;
                    	}

                    	retval.Tree = root_0;
                    }
                    break;

            }
            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "statement"

    public class block_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "block"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:26:1: block : ( ^(b= ELEMENT ( element )* ) | ^(ce= CODE ( element )* ) | ^(ht= HTML ( element )* ) | ^(xm= XML ( element )* ) );
    public WikiTree.block_return block() // throws RecognitionException [1]
    {   
        WikiTree.block_return retval = new WikiTree.block_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree b = null;
        CommonTree ce = null;
        CommonTree ht = null;
        CommonTree xm = null;
        WikiTree.element_return element5 = default(WikiTree.element_return);

        WikiTree.element_return element6 = default(WikiTree.element_return);

        WikiTree.element_return element7 = default(WikiTree.element_return);

        WikiTree.element_return element8 = default(WikiTree.element_return);


        CommonTree b_tree=null;
        CommonTree ce_tree=null;
        CommonTree ht_tree=null;
        CommonTree xm_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:26:10: ( ^(b= ELEMENT ( element )* ) | ^(ce= CODE ( element )* ) | ^(ht= HTML ( element )* ) | ^(xm= XML ( element )* ) )
            int alt7 = 4;
            switch ( input.LA(1) ) 
            {
            case ELEMENT:
            	{
                alt7 = 1;
                }
                break;
            case CODE:
            	{
                alt7 = 2;
                }
                break;
            case HTML:
            	{
                alt7 = 3;
                }
                break;
            case XML:
            	{
                alt7 = 4;
                }
                break;
            	default:
            	    NoViableAltException nvae_d7s0 =
            	        new NoViableAltException("", 7, 0, input);

            	    throw nvae_d7s0;
            }

            switch (alt7) 
            {
                case 1 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:26:14: ^(b= ELEMENT ( element )* )
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	{
                    	CommonTree _save_last_1 = _last;
                    	CommonTree _first_1 = null;
                    	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
                    	b=(CommonTree)Match(input,ELEMENT,FOLLOW_ELEMENT_in_block90); 
                    		b_tree = (CommonTree)adaptor.DupNode(b);

                    		root_1 = (CommonTree)adaptor.BecomeRoot(b_tree, root_1);


                    	 BlockTag(b.Text, false); 

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); 
                    	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:26:56: ( element )*
                    	    do 
                    	    {
                    	        int alt3 = 2;
                    	        int LA3_0 = input.LA(1);

                    	        if ( ((LA3_0 >= NEWLINE && LA3_0 <= QUOTED) || LA3_0 == LT || (LA3_0 >= GT && LA3_0 <= ESCAPE) || LA3_0 == NOCONTROL || (LA3_0 >= STYLES && LA3_0 <= COLORS) || (LA3_0 >= ENCODED && LA3_0 <= HTML_BASE) || (LA3_0 >= WORD && LA3_0 <= NUMERIC)) )
                    	        {
                    	            alt3 = 1;
                    	        }


                    	        switch (alt3) 
                    	    	{
                    	    		case 1 :
                    	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:26:57: element
                    	    		    {
                    	    		    	_last = (CommonTree)input.LT(1);
                    	    		    	PushFollow(FOLLOW_element_in_block95);
                    	    		    	element5 = element();
                    	    		    	state.followingStackPointer--;

                    	    		    	adaptor.AddChild(root_1, element5.Tree);

                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop3;
                    	        }
                    	    } while (true);

                    	    loop3:
                    	    	;	// Stops C# compiler whining that label 'loop3' has no statements

                    	     BlockTag(b.Text, true); 

                    	    Match(input, Token.UP, null); 
                    	}adaptor.AddChild(root_0, root_1);_last = _save_last_1;
                    	}


                    }
                    break;
                case 2 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:27:14: ^(ce= CODE ( element )* )
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	{
                    	CommonTree _save_last_1 = _last;
                    	CommonTree _first_1 = null;
                    	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
                    	ce=(CommonTree)Match(input,CODE,FOLLOW_CODE_in_block120); 
                    		ce_tree = (CommonTree)adaptor.DupNode(ce);

                    		root_1 = (CommonTree)adaptor.BecomeRoot(ce_tree, root_1);


                    	 BlockTag(ce.Text, false); 

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); 
                    	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:27:57: ( element )*
                    	    do 
                    	    {
                    	        int alt4 = 2;
                    	        int LA4_0 = input.LA(1);

                    	        if ( ((LA4_0 >= NEWLINE && LA4_0 <= QUOTED) || LA4_0 == LT || (LA4_0 >= GT && LA4_0 <= ESCAPE) || LA4_0 == NOCONTROL || (LA4_0 >= STYLES && LA4_0 <= COLORS) || (LA4_0 >= ENCODED && LA4_0 <= HTML_BASE) || (LA4_0 >= WORD && LA4_0 <= NUMERIC)) )
                    	        {
                    	            alt4 = 1;
                    	        }


                    	        switch (alt4) 
                    	    	{
                    	    		case 1 :
                    	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:27:58: element
                    	    		    {
                    	    		    	_last = (CommonTree)input.LT(1);
                    	    		    	PushFollow(FOLLOW_element_in_block127);
                    	    		    	element6 = element();
                    	    		    	state.followingStackPointer--;

                    	    		    	adaptor.AddChild(root_1, element6.Tree);

                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop4;
                    	        }
                    	    } while (true);

                    	    loop4:
                    	    	;	// Stops C# compiler whining that label 'loop4' has no statements

                    	     BlockTag(ce.Text, true); 

                    	    Match(input, Token.UP, null); 
                    	}adaptor.AddChild(root_0, root_1);_last = _save_last_1;
                    	}


                    }
                    break;
                case 3 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:28:14: ^(ht= HTML ( element )* )
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	{
                    	CommonTree _save_last_1 = _last;
                    	CommonTree _first_1 = null;
                    	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
                    	ht=(CommonTree)Match(input,HTML,FOLLOW_HTML_in_block153); 
                    		ht_tree = (CommonTree)adaptor.DupNode(ht);

                    		root_1 = (CommonTree)adaptor.BecomeRoot(ht_tree, root_1);


                    	 BlockTag(ht.Text, false); 

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); 
                    	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:28:57: ( element )*
                    	    do 
                    	    {
                    	        int alt5 = 2;
                    	        int LA5_0 = input.LA(1);

                    	        if ( ((LA5_0 >= NEWLINE && LA5_0 <= QUOTED) || LA5_0 == LT || (LA5_0 >= GT && LA5_0 <= ESCAPE) || LA5_0 == NOCONTROL || (LA5_0 >= STYLES && LA5_0 <= COLORS) || (LA5_0 >= ENCODED && LA5_0 <= HTML_BASE) || (LA5_0 >= WORD && LA5_0 <= NUMERIC)) )
                    	        {
                    	            alt5 = 1;
                    	        }


                    	        switch (alt5) 
                    	    	{
                    	    		case 1 :
                    	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:28:58: element
                    	    		    {
                    	    		    	_last = (CommonTree)input.LT(1);
                    	    		    	PushFollow(FOLLOW_element_in_block160);
                    	    		    	element7 = element();
                    	    		    	state.followingStackPointer--;

                    	    		    	adaptor.AddChild(root_1, element7.Tree);

                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop5;
                    	        }
                    	    } while (true);

                    	    loop5:
                    	    	;	// Stops C# compiler whining that label 'loop5' has no statements

                    	     BlockTag(ht.Text, true); 

                    	    Match(input, Token.UP, null); 
                    	}adaptor.AddChild(root_0, root_1);_last = _save_last_1;
                    	}


                    }
                    break;
                case 4 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:29:14: ^(xm= XML ( element )* )
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	{
                    	CommonTree _save_last_1 = _last;
                    	CommonTree _first_1 = null;
                    	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
                    	xm=(CommonTree)Match(input,XML,FOLLOW_XML_in_block186); 
                    		xm_tree = (CommonTree)adaptor.DupNode(xm);

                    		root_1 = (CommonTree)adaptor.BecomeRoot(xm_tree, root_1);


                    	 BlockTag(xm.Text, false); 

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); 
                    	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:29:57: ( element )*
                    	    do 
                    	    {
                    	        int alt6 = 2;
                    	        int LA6_0 = input.LA(1);

                    	        if ( ((LA6_0 >= NEWLINE && LA6_0 <= QUOTED) || LA6_0 == LT || (LA6_0 >= GT && LA6_0 <= ESCAPE) || LA6_0 == NOCONTROL || (LA6_0 >= STYLES && LA6_0 <= COLORS) || (LA6_0 >= ENCODED && LA6_0 <= HTML_BASE) || (LA6_0 >= WORD && LA6_0 <= NUMERIC)) )
                    	        {
                    	            alt6 = 1;
                    	        }


                    	        switch (alt6) 
                    	    	{
                    	    		case 1 :
                    	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:29:58: element
                    	    		    {
                    	    		    	_last = (CommonTree)input.LT(1);
                    	    		    	PushFollow(FOLLOW_element_in_block194);
                    	    		    	element8 = element();
                    	    		    	state.followingStackPointer--;

                    	    		    	adaptor.AddChild(root_1, element8.Tree);

                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop6;
                    	        }
                    	    } while (true);

                    	    loop6:
                    	    	;	// Stops C# compiler whining that label 'loop6' has no statements

                    	     BlockTag(xm.Text, true); 

                    	    Match(input, Token.UP, null); 
                    	}adaptor.AddChild(root_0, root_1);_last = _save_last_1;
                    	}


                    }
                    break;

            }
            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "block"

    public class lists_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "lists"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:31:1: lists : ( ^(l= LIST ( NEWLINE )* ( listItem )* ( NEWLINE )* ) | ^(n= NUMERIC ( NEWLINE )* ( listItem )* ( NEWLINE )* ) );
    public WikiTree.lists_return lists() // throws RecognitionException [1]
    {   
        WikiTree.lists_return retval = new WikiTree.lists_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree l = null;
        CommonTree n = null;
        CommonTree NEWLINE9 = null;
        CommonTree NEWLINE11 = null;
        CommonTree NEWLINE12 = null;
        CommonTree NEWLINE14 = null;
        WikiTree.listItem_return listItem10 = default(WikiTree.listItem_return);

        WikiTree.listItem_return listItem13 = default(WikiTree.listItem_return);


        CommonTree l_tree=null;
        CommonTree n_tree=null;
        CommonTree NEWLINE9_tree=null;
        CommonTree NEWLINE11_tree=null;
        CommonTree NEWLINE12_tree=null;
        CommonTree NEWLINE14_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:31:10: ( ^(l= LIST ( NEWLINE )* ( listItem )* ( NEWLINE )* ) | ^(n= NUMERIC ( NEWLINE )* ( listItem )* ( NEWLINE )* ) )
            int alt14 = 2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0 == LIST) )
            {
                alt14 = 1;
            }
            else if ( (LA14_0 == NUMERIC) )
            {
                alt14 = 2;
            }
            else 
            {
                NoViableAltException nvae_d14s0 =
                    new NoViableAltException("", 14, 0, input);

                throw nvae_d14s0;
            }
            switch (alt14) 
            {
                case 1 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:31:14: ^(l= LIST ( NEWLINE )* ( listItem )* ( NEWLINE )* )
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	{
                    	CommonTree _save_last_1 = _last;
                    	CommonTree _first_1 = null;
                    	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
                    	l=(CommonTree)Match(input,LIST,FOLLOW_LIST_in_lists218); 
                    		l_tree = (CommonTree)adaptor.DupNode(l);

                    		root_1 = (CommonTree)adaptor.BecomeRoot(l_tree, root_1);


                    	 BlockTag("UL", false); 

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); 
                    	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:31:53: ( NEWLINE )*
                    	    do 
                    	    {
                    	        int alt8 = 2;
                    	        int LA8_0 = input.LA(1);

                    	        if ( (LA8_0 == NEWLINE) )
                    	        {
                    	            alt8 = 1;
                    	        }


                    	        switch (alt8) 
                    	    	{
                    	    		case 1 :
                    	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:31:53: NEWLINE
                    	    		    {
                    	    		    	_last = (CommonTree)input.LT(1);
                    	    		    	NEWLINE9=(CommonTree)Match(input,NEWLINE,FOLLOW_NEWLINE_in_lists225); 
                    	    		    		NEWLINE9_tree = (CommonTree)adaptor.DupNode(NEWLINE9);

                    	    		    		adaptor.AddChild(root_1, NEWLINE9_tree);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop8;
                    	        }
                    	    } while (true);

                    	    loop8:
                    	    	;	// Stops C# compiler whining that label 'loop8' has no statements

                    	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:31:62: ( listItem )*
                    	    do 
                    	    {
                    	        int alt9 = 2;
                    	        int LA9_0 = input.LA(1);

                    	        if ( ((LA9_0 >= NEWLINE && LA9_0 <= QUOTED) || LA9_0 == LT || (LA9_0 >= GT && LA9_0 <= ESCAPE) || LA9_0 == NOCONTROL || (LA9_0 >= STYLES && LA9_0 <= COLORS) || (LA9_0 >= ENCODED && LA9_0 <= HTML_BASE) || (LA9_0 >= WORD && LA9_0 <= NUMERIC)) )
                    	        {
                    	            alt9 = 1;
                    	        }


                    	        switch (alt9) 
                    	    	{
                    	    		case 1 :
                    	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:31:63: listItem
                    	    		    {
                    	    		    	_last = (CommonTree)input.LT(1);
                    	    		    	PushFollow(FOLLOW_listItem_in_lists229);
                    	    		    	listItem10 = listItem();
                    	    		    	state.followingStackPointer--;

                    	    		    	adaptor.AddChild(root_1, listItem10.Tree);

                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop9;
                    	        }
                    	    } while (true);

                    	    loop9:
                    	    	;	// Stops C# compiler whining that label 'loop9' has no statements

                    	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:31:74: ( NEWLINE )*
                    	    do 
                    	    {
                    	        int alt10 = 2;
                    	        int LA10_0 = input.LA(1);

                    	        if ( (LA10_0 == NEWLINE) )
                    	        {
                    	            alt10 = 1;
                    	        }


                    	        switch (alt10) 
                    	    	{
                    	    		case 1 :
                    	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:31:74: NEWLINE
                    	    		    {
                    	    		    	_last = (CommonTree)input.LT(1);
                    	    		    	NEWLINE11=(CommonTree)Match(input,NEWLINE,FOLLOW_NEWLINE_in_lists233); 
                    	    		    		NEWLINE11_tree = (CommonTree)adaptor.DupNode(NEWLINE11);

                    	    		    		adaptor.AddChild(root_1, NEWLINE11_tree);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop10;
                    	        }
                    	    } while (true);

                    	    loop10:
                    	    	;	// Stops C# compiler whining that label 'loop10' has no statements

                    	     BlockTag("UL", true); 

                    	    Match(input, Token.UP, null); 
                    	}adaptor.AddChild(root_0, root_1);_last = _save_last_1;
                    	}


                    }
                    break;
                case 2 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:32:14: ^(n= NUMERIC ( NEWLINE )* ( listItem )* ( NEWLINE )* )
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	{
                    	CommonTree _save_last_1 = _last;
                    	CommonTree _first_1 = null;
                    	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
                    	n=(CommonTree)Match(input,NUMERIC,FOLLOW_NUMERIC_in_lists256); 
                    		n_tree = (CommonTree)adaptor.DupNode(n);

                    		root_1 = (CommonTree)adaptor.BecomeRoot(n_tree, root_1);


                    	 BlockTag("OL", false); 

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); 
                    	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:32:53: ( NEWLINE )*
                    	    do 
                    	    {
                    	        int alt11 = 2;
                    	        int LA11_0 = input.LA(1);

                    	        if ( (LA11_0 == NEWLINE) )
                    	        {
                    	            alt11 = 1;
                    	        }


                    	        switch (alt11) 
                    	    	{
                    	    		case 1 :
                    	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:32:53: NEWLINE
                    	    		    {
                    	    		    	_last = (CommonTree)input.LT(1);
                    	    		    	NEWLINE12=(CommonTree)Match(input,NEWLINE,FOLLOW_NEWLINE_in_lists260); 
                    	    		    		NEWLINE12_tree = (CommonTree)adaptor.DupNode(NEWLINE12);

                    	    		    		adaptor.AddChild(root_1, NEWLINE12_tree);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop11;
                    	        }
                    	    } while (true);

                    	    loop11:
                    	    	;	// Stops C# compiler whining that label 'loop11' has no statements

                    	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:32:62: ( listItem )*
                    	    do 
                    	    {
                    	        int alt12 = 2;
                    	        int LA12_0 = input.LA(1);

                    	        if ( ((LA12_0 >= NEWLINE && LA12_0 <= QUOTED) || LA12_0 == LT || (LA12_0 >= GT && LA12_0 <= ESCAPE) || LA12_0 == NOCONTROL || (LA12_0 >= STYLES && LA12_0 <= COLORS) || (LA12_0 >= ENCODED && LA12_0 <= HTML_BASE) || (LA12_0 >= WORD && LA12_0 <= NUMERIC)) )
                    	        {
                    	            alt12 = 1;
                    	        }


                    	        switch (alt12) 
                    	    	{
                    	    		case 1 :
                    	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:32:63: listItem
                    	    		    {
                    	    		    	_last = (CommonTree)input.LT(1);
                    	    		    	PushFollow(FOLLOW_listItem_in_lists264);
                    	    		    	listItem13 = listItem();
                    	    		    	state.followingStackPointer--;

                    	    		    	adaptor.AddChild(root_1, listItem13.Tree);

                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop12;
                    	        }
                    	    } while (true);

                    	    loop12:
                    	    	;	// Stops C# compiler whining that label 'loop12' has no statements

                    	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:32:74: ( NEWLINE )*
                    	    do 
                    	    {
                    	        int alt13 = 2;
                    	        int LA13_0 = input.LA(1);

                    	        if ( (LA13_0 == NEWLINE) )
                    	        {
                    	            alt13 = 1;
                    	        }


                    	        switch (alt13) 
                    	    	{
                    	    		case 1 :
                    	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:32:74: NEWLINE
                    	    		    {
                    	    		    	_last = (CommonTree)input.LT(1);
                    	    		    	NEWLINE14=(CommonTree)Match(input,NEWLINE,FOLLOW_NEWLINE_in_lists268); 
                    	    		    		NEWLINE14_tree = (CommonTree)adaptor.DupNode(NEWLINE14);

                    	    		    		adaptor.AddChild(root_1, NEWLINE14_tree);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop13;
                    	        }
                    	    } while (true);

                    	    loop13:
                    	    	;	// Stops C# compiler whining that label 'loop13' has no statements

                    	     BlockTag("OL", true); 

                    	    Match(input, Token.UP, null); 
                    	}adaptor.AddChild(root_0, root_1);_last = _save_last_1;
                    	}


                    }
                    break;

            }
            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "lists"

    public class listItem_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "listItem"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:34:1: listItem : ( element ) ;
    public WikiTree.listItem_return listItem() // throws RecognitionException [1]
    {   
        WikiTree.listItem_return retval = new WikiTree.listItem_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        WikiTree.element_return element15 = default(WikiTree.element_return);



        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:34:10: ( ( element ) )
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:34:14: ( element )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:34:14: ( element )
            	// D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:34:16: element
            	{
            		 BlockTag("LI", false); 
            		_last = (CommonTree)input.LT(1);
            		PushFollow(FOLLOW_element_in_listItem303);
            		element15 = element();
            		state.followingStackPointer--;

            		adaptor.AddChild(root_0, element15.Tree);
            		 BlockTag("LI", true); 

            	}


            }

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "listItem"

    public class element_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "element"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:40:1: element : ( block | lists | atom | codeText | tag );
    public WikiTree.element_return element() // throws RecognitionException [1]
    {   
        WikiTree.element_return retval = new WikiTree.element_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        WikiTree.block_return block16 = default(WikiTree.block_return);

        WikiTree.lists_return lists17 = default(WikiTree.lists_return);

        WikiTree.atom_return atom18 = default(WikiTree.atom_return);

        WikiTree.codeText_return codeText19 = default(WikiTree.codeText_return);

        WikiTree.tag_return tag20 = default(WikiTree.tag_return);



        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:40:10: ( block | lists | atom | codeText | tag )
            int alt15 = 5;
            switch ( input.LA(1) ) 
            {
            case ELEMENT:
            case CODE:
            case XML:
            case HTML:
            	{
                alt15 = 1;
                }
                break;
            case LIST:
            case NUMERIC:
            	{
                alt15 = 2;
                }
                break;
            case NAME_ELEMENT:
            case A_ELEMENT:
            case IMG_ELEMENT:
            case INLINE:
            	{
                alt15 = 3;
                }
                break;
            case NEWLINE:
            case WS:
            case COMMENT:
            case QUOTED:
            case LT:
            case GT:
            case ESCAPE:
            case NOCONTROL:
            case STYLES:
            case COLORS:
            case ENCODED:
            case SYMBOLS:
            case CSHARP_BASE:
            case CSHARP_TYPES:
            case CSHARP_FLOW:
            case CSHARP_SPECIAL:
            case HTML_BASE:
            case WORD:
            	{
                alt15 = 4;
                }
                break;
            case TAG:
            	{
                alt15 = 5;
                }
                break;
            	default:
            	    NoViableAltException nvae_d15s0 =
            	        new NoViableAltException("", 15, 0, input);

            	    throw nvae_d15s0;
            }

            switch (alt15) 
            {
                case 1 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:40:12: block
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_block_in_element332);
                    	block16 = block();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, block16.Tree);

                    }
                    break;
                case 2 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:40:20: lists
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_lists_in_element336);
                    	lists17 = lists();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, lists17.Tree);

                    }
                    break;
                case 3 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:40:28: atom
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_atom_in_element340);
                    	atom18 = atom();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, atom18.Tree);

                    }
                    break;
                case 4 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:40:35: codeText
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_codeText_in_element344);
                    	codeText19 = codeText();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, codeText19.Tree);

                    }
                    break;
                case 5 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:40:46: tag
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_tag_in_element348);
                    	tag20 = tag();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, tag20.Tree);

                    }
                    break;

            }
            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "element"

    public class inlineElement_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "inlineElement"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:42:1: inlineElement : ( atom | codeText | tag );
    public WikiTree.inlineElement_return inlineElement() // throws RecognitionException [1]
    {   
        WikiTree.inlineElement_return retval = new WikiTree.inlineElement_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        WikiTree.atom_return atom21 = default(WikiTree.atom_return);

        WikiTree.codeText_return codeText22 = default(WikiTree.codeText_return);

        WikiTree.tag_return tag23 = default(WikiTree.tag_return);



        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:42:14: ( atom | codeText | tag )
            int alt16 = 3;
            switch ( input.LA(1) ) 
            {
            case NAME_ELEMENT:
            case A_ELEMENT:
            case IMG_ELEMENT:
            case INLINE:
            	{
                alt16 = 1;
                }
                break;
            case NEWLINE:
            case WS:
            case COMMENT:
            case QUOTED:
            case LT:
            case GT:
            case ESCAPE:
            case NOCONTROL:
            case STYLES:
            case COLORS:
            case ENCODED:
            case SYMBOLS:
            case CSHARP_BASE:
            case CSHARP_TYPES:
            case CSHARP_FLOW:
            case CSHARP_SPECIAL:
            case HTML_BASE:
            case WORD:
            	{
                alt16 = 2;
                }
                break;
            case TAG:
            	{
                alt16 = 3;
                }
                break;
            	default:
            	    NoViableAltException nvae_d16s0 =
            	        new NoViableAltException("", 16, 0, input);

            	    throw nvae_d16s0;
            }

            switch (alt16) 
            {
                case 1 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:42:16: atom
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_atom_in_inlineElement355);
                    	atom21 = atom();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, atom21.Tree);

                    }
                    break;
                case 2 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:42:23: codeText
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_codeText_in_inlineElement359);
                    	codeText22 = codeText();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, codeText22.Tree);

                    }
                    break;
                case 3 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:42:34: tag
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_tag_in_inlineElement363);
                    	tag23 = tag();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, tag23.Tree);

                    }
                    break;

            }
            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "inlineElement"

    public class atom_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "atom"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:44:1: atom : ( inline | anchor | name | image );
    public WikiTree.atom_return atom() // throws RecognitionException [1]
    {   
        WikiTree.atom_return retval = new WikiTree.atom_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        WikiTree.inline_return inline24 = default(WikiTree.inline_return);

        WikiTree.anchor_return anchor25 = default(WikiTree.anchor_return);

        WikiTree.name_return name26 = default(WikiTree.name_return);

        WikiTree.image_return image27 = default(WikiTree.image_return);



        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:44:9: ( inline | anchor | name | image )
            int alt17 = 4;
            switch ( input.LA(1) ) 
            {
            case INLINE:
            	{
                alt17 = 1;
                }
                break;
            case A_ELEMENT:
            	{
                alt17 = 2;
                }
                break;
            case NAME_ELEMENT:
            	{
                alt17 = 3;
                }
                break;
            case IMG_ELEMENT:
            	{
                alt17 = 4;
                }
                break;
            	default:
            	    NoViableAltException nvae_d17s0 =
            	        new NoViableAltException("", 17, 0, input);

            	    throw nvae_d17s0;
            }

            switch (alt17) 
            {
                case 1 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:44:11: inline
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_inline_in_atom374);
                    	inline24 = inline();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, inline24.Tree);

                    }
                    break;
                case 2 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:44:20: anchor
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_anchor_in_atom378);
                    	anchor25 = anchor();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, anchor25.Tree);

                    }
                    break;
                case 3 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:44:29: name
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_name_in_atom382);
                    	name26 = name();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, name26.Tree);

                    }
                    break;
                case 4 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:44:36: image
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_image_in_atom386);
                    	image27 = image();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, image27.Tree);

                    }
                    break;

            }
            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "atom"

    public class inline_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "inline"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:48:1: inline : ^(i= INLINE ( inlineElement )* ) ;
    public WikiTree.inline_return inline() // throws RecognitionException [1]
    {   
        WikiTree.inline_return retval = new WikiTree.inline_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree i = null;
        WikiTree.inlineElement_return inlineElement28 = default(WikiTree.inlineElement_return);


        CommonTree i_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:48:9: ( ^(i= INLINE ( inlineElement )* ) )
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:48:13: ^(i= INLINE ( inlineElement )* )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	_last = (CommonTree)input.LT(1);
            	{
            	CommonTree _save_last_1 = _last;
            	CommonTree _first_1 = null;
            	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
            	i=(CommonTree)Match(input,INLINE,FOLLOW_INLINE_in_inline403); 
            		i_tree = (CommonTree)adaptor.DupNode(i);

            		root_1 = (CommonTree)adaptor.BecomeRoot(i_tree, root_1);


            	 InlineTag(i.Text, false); 

            	if ( input.LA(1) == Token.DOWN )
            	{
            	    Match(input, Token.DOWN, null); 
            	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:49:17: ( inlineElement )*
            	    do 
            	    {
            	        int alt18 = 2;
            	        int LA18_0 = input.LA(1);

            	        if ( ((LA18_0 >= NEWLINE && LA18_0 <= QUOTED) || LA18_0 == LT || (LA18_0 >= GT && LA18_0 <= ESCAPE) || LA18_0 == NOCONTROL || (LA18_0 >= STYLES && LA18_0 <= COLORS) || (LA18_0 >= ENCODED && LA18_0 <= HTML_BASE) || LA18_0 == WORD || (LA18_0 >= NAME_ELEMENT && LA18_0 <= IMG_ELEMENT) || (LA18_0 >= INLINE && LA18_0 <= TAG)) )
            	        {
            	            alt18 = 1;
            	        }


            	        switch (alt18) 
            	    	{
            	    		case 1 :
            	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:49:18: inlineElement
            	    		    {
            	    		    	_last = (CommonTree)input.LT(1);
            	    		    	PushFollow(FOLLOW_inlineElement_in_inline428);
            	    		    	inlineElement28 = inlineElement();
            	    		    	state.followingStackPointer--;

            	    		    	adaptor.AddChild(root_1, inlineElement28.Tree);

            	    		    }
            	    		    break;

            	    		default:
            	    		    goto loop18;
            	        }
            	    } while (true);

            	    loop18:
            	    	;	// Stops C# compiler whining that label 'loop18' has no statements

            	     InlineTag(i.Text, true); 

            	    Match(input, Token.UP, null); 
            	}adaptor.AddChild(root_0, root_1);_last = _save_last_1;
            	}


            }

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "inline"

    public class anchor_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "anchor"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:52:1: anchor : ^( A_ELEMENT ( pureText )* attrText ) ;
    public WikiTree.anchor_return anchor() // throws RecognitionException [1]
    {   
        WikiTree.anchor_return retval = new WikiTree.anchor_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree A_ELEMENT29 = null;
        WikiTree.pureText_return pureText30 = default(WikiTree.pureText_return);

        WikiTree.attrText_return attrText31 = default(WikiTree.attrText_return);


        CommonTree A_ELEMENT29_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:52:9: ( ^( A_ELEMENT ( pureText )* attrText ) )
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:52:11: ^( A_ELEMENT ( pureText )* attrText )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	_last = (CommonTree)input.LT(1);
            	{
            	CommonTree _save_last_1 = _last;
            	CommonTree _first_1 = null;
            	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
            	A_ELEMENT29=(CommonTree)Match(input,A_ELEMENT,FOLLOW_A_ELEMENT_in_anchor467); 
            		A_ELEMENT29_tree = (CommonTree)adaptor.DupNode(A_ELEMENT29);

            		root_1 = (CommonTree)adaptor.BecomeRoot(A_ELEMENT29_tree, root_1);


            	 SpecialTextStart(); 

            	Match(input, Token.DOWN, null); 
            	// D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:52:49: ( pureText )*
            	do 
            	{
            	    int alt19 = 2;
            	    int LA19_0 = input.LA(1);

            	    if ( ((LA19_0 >= NEWLINE && LA19_0 <= QUOTED) || LA19_0 == LT || (LA19_0 >= GT && LA19_0 <= ESCAPE) || LA19_0 == NOCONTROL || (LA19_0 >= STYLES && LA19_0 <= COLORS) || (LA19_0 >= ENCODED && LA19_0 <= HTML_BASE) || LA19_0 == WORD) )
            	    {
            	        alt19 = 1;
            	    }


            	    switch (alt19) 
            		{
            			case 1 :
            			    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:52:50: pureText
            			    {
            			    	_last = (CommonTree)input.LT(1);
            			    	PushFollow(FOLLOW_pureText_in_anchor474);
            			    	pureText30 = pureText();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_1, pureText30.Tree);

            			    }
            			    break;

            			default:
            			    goto loop19;
            	    }
            	} while (true);

            	loop19:
            		;	// Stops C# compiler whining that label 'loop19' has no statements

            	 SpecialTextEnd(AnchorTemplate);
            	_last = (CommonTree)input.LT(1);
            	PushFollow(FOLLOW_attrText_in_anchor504);
            	attrText31 = attrText();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_1, attrText31.Tree);
            	 Append("</a>");

            	Match(input, Token.UP, null); adaptor.AddChild(root_0, root_1);_last = _save_last_1;
            	}


            }

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "anchor"

    public class name_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "name"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:56:1: name : ^( NAME_ELEMENT ( pureText )* ) ;
    public WikiTree.name_return name() // throws RecognitionException [1]
    {   
        WikiTree.name_return retval = new WikiTree.name_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree NAME_ELEMENT32 = null;
        WikiTree.pureText_return pureText33 = default(WikiTree.pureText_return);


        CommonTree NAME_ELEMENT32_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:56:10: ( ^( NAME_ELEMENT ( pureText )* ) )
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:56:12: ^( NAME_ELEMENT ( pureText )* )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	_last = (CommonTree)input.LT(1);
            	{
            	CommonTree _save_last_1 = _last;
            	CommonTree _first_1 = null;
            	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
            	NAME_ELEMENT32=(CommonTree)Match(input,NAME_ELEMENT,FOLLOW_NAME_ELEMENT_in_name533); 
            		NAME_ELEMENT32_tree = (CommonTree)adaptor.DupNode(NAME_ELEMENT32);

            		root_1 = (CommonTree)adaptor.BecomeRoot(NAME_ELEMENT32_tree, root_1);


            	 Append("<a name=\""); 

            	if ( input.LA(1) == Token.DOWN )
            	{
            	    Match(input, Token.DOWN, null); 
            	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:56:52: ( pureText )*
            	    do 
            	    {
            	        int alt20 = 2;
            	        int LA20_0 = input.LA(1);

            	        if ( ((LA20_0 >= NEWLINE && LA20_0 <= QUOTED) || LA20_0 == LT || (LA20_0 >= GT && LA20_0 <= ESCAPE) || LA20_0 == NOCONTROL || (LA20_0 >= STYLES && LA20_0 <= COLORS) || (LA20_0 >= ENCODED && LA20_0 <= HTML_BASE) || LA20_0 == WORD) )
            	        {
            	            alt20 = 1;
            	        }


            	        switch (alt20) 
            	    	{
            	    		case 1 :
            	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:56:53: pureText
            	    		    {
            	    		    	_last = (CommonTree)input.LT(1);
            	    		    	PushFollow(FOLLOW_pureText_in_name537);
            	    		    	pureText33 = pureText();
            	    		    	state.followingStackPointer--;

            	    		    	adaptor.AddChild(root_1, pureText33.Tree);

            	    		    }
            	    		    break;

            	    		default:
            	    		    goto loop20;
            	        }
            	    } while (true);

            	    loop20:
            	    	;	// Stops C# compiler whining that label 'loop20' has no statements

            	     Append("\" ></a>");

            	    Match(input, Token.UP, null); 
            	}adaptor.AddChild(root_0, root_1);_last = _save_last_1;
            	}


            }

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "name"

    public class image_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "image"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:59:1: image : ^( IMG_ELEMENT ( pureText )* ( heightText | widthText | floatText )* ) ;
    public WikiTree.image_return image() // throws RecognitionException [1]
    {   
        WikiTree.image_return retval = new WikiTree.image_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree IMG_ELEMENT34 = null;
        WikiTree.pureText_return pureText35 = default(WikiTree.pureText_return);

        WikiTree.heightText_return heightText36 = default(WikiTree.heightText_return);

        WikiTree.widthText_return widthText37 = default(WikiTree.widthText_return);

        WikiTree.floatText_return floatText38 = default(WikiTree.floatText_return);


        CommonTree IMG_ELEMENT34_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:59:10: ( ^( IMG_ELEMENT ( pureText )* ( heightText | widthText | floatText )* ) )
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:59:12: ^( IMG_ELEMENT ( pureText )* ( heightText | widthText | floatText )* )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	_last = (CommonTree)input.LT(1);
            	{
            	CommonTree _save_last_1 = _last;
            	CommonTree _first_1 = null;
            	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
            	IMG_ELEMENT34=(CommonTree)Match(input,IMG_ELEMENT,FOLLOW_IMG_ELEMENT_in_image568); 
            		IMG_ELEMENT34_tree = (CommonTree)adaptor.DupNode(IMG_ELEMENT34);

            		root_1 = (CommonTree)adaptor.BecomeRoot(IMG_ELEMENT34_tree, root_1);


            	 SpecialTextStart(); 

            	if ( input.LA(1) == Token.DOWN )
            	{
            	    Match(input, Token.DOWN, null); 
            	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:59:50: ( pureText )*
            	    do 
            	    {
            	        int alt21 = 2;
            	        int LA21_0 = input.LA(1);

            	        if ( ((LA21_0 >= NEWLINE && LA21_0 <= QUOTED) || LA21_0 == LT || (LA21_0 >= GT && LA21_0 <= ESCAPE) || LA21_0 == NOCONTROL || (LA21_0 >= STYLES && LA21_0 <= COLORS) || (LA21_0 >= ENCODED && LA21_0 <= HTML_BASE) || LA21_0 == WORD) )
            	        {
            	            alt21 = 1;
            	        }


            	        switch (alt21) 
            	    	{
            	    		case 1 :
            	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:59:51: pureText
            	    		    {
            	    		    	_last = (CommonTree)input.LT(1);
            	    		    	PushFollow(FOLLOW_pureText_in_image573);
            	    		    	pureText35 = pureText();
            	    		    	state.followingStackPointer--;

            	    		    	adaptor.AddChild(root_1, pureText35.Tree);

            	    		    }
            	    		    break;

            	    		default:
            	    		    goto loop21;
            	        }
            	    } while (true);

            	    loop21:
            	    	;	// Stops C# compiler whining that label 'loop21' has no statements

            	     SpecialTextEnd(ImageTemplate);
            	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:60:25: ( heightText | widthText | floatText )*
            	    do 
            	    {
            	        int alt22 = 4;
            	        switch ( input.LA(1) ) 
            	        {
            	        case ATTR_HEIGHT:
            	        	{
            	            alt22 = 1;
            	            }
            	            break;
            	        case ATTR_WIDTH:
            	        	{
            	            alt22 = 2;
            	            }
            	            break;
            	        case ATTR_FLOAT:
            	        	{
            	            alt22 = 3;
            	            }
            	            break;

            	        }

            	        switch (alt22) 
            	    	{
            	    		case 1 :
            	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:60:26: heightText
            	    		    {
            	    		    	_last = (CommonTree)input.LT(1);
            	    		    	PushFollow(FOLLOW_heightText_in_image604);
            	    		    	heightText36 = heightText();
            	    		    	state.followingStackPointer--;

            	    		    	adaptor.AddChild(root_1, heightText36.Tree);

            	    		    }
            	    		    break;
            	    		case 2 :
            	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:60:39: widthText
            	    		    {
            	    		    	_last = (CommonTree)input.LT(1);
            	    		    	PushFollow(FOLLOW_widthText_in_image608);
            	    		    	widthText37 = widthText();
            	    		    	state.followingStackPointer--;

            	    		    	adaptor.AddChild(root_1, widthText37.Tree);

            	    		    }
            	    		    break;
            	    		case 3 :
            	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:60:51: floatText
            	    		    {
            	    		    	_last = (CommonTree)input.LT(1);
            	    		    	PushFollow(FOLLOW_floatText_in_image612);
            	    		    	floatText38 = floatText();
            	    		    	state.followingStackPointer--;

            	    		    	adaptor.AddChild(root_1, floatText38.Tree);

            	    		    }
            	    		    break;

            	    		default:
            	    		    goto loop22;
            	        }
            	    } while (true);

            	    loop22:
            	    	;	// Stops C# compiler whining that label 'loop22' has no statements

            	     Append("\" />");

            	    Match(input, Token.UP, null); 
            	}adaptor.AddChild(root_0, root_1);_last = _save_last_1;
            	}


            }

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "image"

    public class tag_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "tag"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:64:1: tag : ^( TAG ( codeText )* ) ;
    public WikiTree.tag_return tag() // throws RecognitionException [1]
    {   
        WikiTree.tag_return retval = new WikiTree.tag_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree TAG39 = null;
        WikiTree.codeText_return codeText40 = default(WikiTree.codeText_return);


        CommonTree TAG39_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:64:10: ( ^( TAG ( codeText )* ) )
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:64:12: ^( TAG ( codeText )* )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	_last = (CommonTree)input.LT(1);
            	{
            	CommonTree _save_last_1 = _last;
            	CommonTree _first_1 = null;
            	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
            	TAG39=(CommonTree)Match(input,TAG,FOLLOW_TAG_in_tag646); 
            		TAG39_tree = (CommonTree)adaptor.DupNode(TAG39);

            		root_1 = (CommonTree)adaptor.BecomeRoot(TAG39_tree, root_1);


            	 TagElement(false); 

            	if ( input.LA(1) == Token.DOWN )
            	{
            	    Match(input, Token.DOWN, null); 
            	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:64:41: ( codeText )*
            	    do 
            	    {
            	        int alt23 = 2;
            	        int LA23_0 = input.LA(1);

            	        if ( ((LA23_0 >= NEWLINE && LA23_0 <= QUOTED) || LA23_0 == LT || (LA23_0 >= GT && LA23_0 <= ESCAPE) || LA23_0 == NOCONTROL || (LA23_0 >= STYLES && LA23_0 <= COLORS) || (LA23_0 >= ENCODED && LA23_0 <= HTML_BASE) || LA23_0 == WORD) )
            	        {
            	            alt23 = 1;
            	        }


            	        switch (alt23) 
            	    	{
            	    		case 1 :
            	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:64:42: codeText
            	    		    {
            	    		    	_last = (CommonTree)input.LT(1);
            	    		    	PushFollow(FOLLOW_codeText_in_tag651);
            	    		    	codeText40 = codeText();
            	    		    	state.followingStackPointer--;

            	    		    	adaptor.AddChild(root_1, codeText40.Tree);

            	    		    }
            	    		    break;

            	    		default:
            	    		    goto loop23;
            	        }
            	    } while (true);

            	    loop23:
            	    	;	// Stops C# compiler whining that label 'loop23' has no statements


            	    Match(input, Token.UP, null); 
            	}adaptor.AddChild(root_0, root_1);_last = _save_last_1;
            	}

            	 TagElement(true); 

            }

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "tag"

    public class attrText_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "attrText"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:67:1: attrText : ^( ATTR_TEXT ( simpleText | image )* ) ;
    public WikiTree.attrText_return attrText() // throws RecognitionException [1]
    {   
        WikiTree.attrText_return retval = new WikiTree.attrText_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree ATTR_TEXT41 = null;
        WikiTree.simpleText_return simpleText42 = default(WikiTree.simpleText_return);

        WikiTree.image_return image43 = default(WikiTree.image_return);


        CommonTree ATTR_TEXT41_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:67:10: ( ^( ATTR_TEXT ( simpleText | image )* ) )
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:67:12: ^( ATTR_TEXT ( simpleText | image )* )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	_last = (CommonTree)input.LT(1);
            	{
            	CommonTree _save_last_1 = _last;
            	CommonTree _first_1 = null;
            	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
            	ATTR_TEXT41=(CommonTree)Match(input,ATTR_TEXT,FOLLOW_ATTR_TEXT_in_attrText667); 
            		ATTR_TEXT41_tree = (CommonTree)adaptor.DupNode(ATTR_TEXT41);

            		root_1 = (CommonTree)adaptor.BecomeRoot(ATTR_TEXT41_tree, root_1);



            	if ( input.LA(1) == Token.DOWN )
            	{
            	    Match(input, Token.DOWN, null); 
            	    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:67:24: ( simpleText | image )*
            	    do 
            	    {
            	        int alt24 = 3;
            	        int LA24_0 = input.LA(1);

            	        if ( ((LA24_0 >= NEWLINE && LA24_0 <= QUOTED) || LA24_0 == LT || (LA24_0 >= GT && LA24_0 <= ESCAPE) || LA24_0 == NOCONTROL || (LA24_0 >= STYLES && LA24_0 <= COLORS) || (LA24_0 >= ENCODED && LA24_0 <= HTML_BASE) || LA24_0 == WORD) )
            	        {
            	            alt24 = 1;
            	        }
            	        else if ( (LA24_0 == IMG_ELEMENT) )
            	        {
            	            alt24 = 2;
            	        }


            	        switch (alt24) 
            	    	{
            	    		case 1 :
            	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:67:25: simpleText
            	    		    {
            	    		    	_last = (CommonTree)input.LT(1);
            	    		    	PushFollow(FOLLOW_simpleText_in_attrText670);
            	    		    	simpleText42 = simpleText();
            	    		    	state.followingStackPointer--;

            	    		    	adaptor.AddChild(root_1, simpleText42.Tree);

            	    		    }
            	    		    break;
            	    		case 2 :
            	    		    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:67:38: image
            	    		    {
            	    		    	_last = (CommonTree)input.LT(1);
            	    		    	PushFollow(FOLLOW_image_in_attrText674);
            	    		    	image43 = image();
            	    		    	state.followingStackPointer--;

            	    		    	adaptor.AddChild(root_1, image43.Tree);

            	    		    }
            	    		    break;

            	    		default:
            	    		    goto loop24;
            	        }
            	    } while (true);

            	    loop24:
            	    	;	// Stops C# compiler whining that label 'loop24' has no statements


            	    Match(input, Token.UP, null); 
            	}adaptor.AddChild(root_0, root_1);_last = _save_last_1;
            	}


            }

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "attrText"

    public class heightText_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "heightText"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:69:1: heightText : ^( ATTR_HEIGHT pt= WORD ) ;
    public WikiTree.heightText_return heightText() // throws RecognitionException [1]
    {   
        WikiTree.heightText_return retval = new WikiTree.heightText_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree pt = null;
        CommonTree ATTR_HEIGHT44 = null;

        CommonTree pt_tree=null;
        CommonTree ATTR_HEIGHT44_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:69:11: ( ^( ATTR_HEIGHT pt= WORD ) )
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:69:13: ^( ATTR_HEIGHT pt= WORD )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	_last = (CommonTree)input.LT(1);
            	{
            	CommonTree _save_last_1 = _last;
            	CommonTree _first_1 = null;
            	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
            	ATTR_HEIGHT44=(CommonTree)Match(input,ATTR_HEIGHT,FOLLOW_ATTR_HEIGHT_in_heightText686); 
            		ATTR_HEIGHT44_tree = (CommonTree)adaptor.DupNode(ATTR_HEIGHT44);

            		root_1 = (CommonTree)adaptor.BecomeRoot(ATTR_HEIGHT44_tree, root_1);



            	Match(input, Token.DOWN, null); 
            	_last = (CommonTree)input.LT(1);
            	pt=(CommonTree)Match(input,WORD,FOLLOW_WORD_in_heightText690); 
            		pt_tree = (CommonTree)adaptor.DupNode(pt);

            		adaptor.AddChild(root_1, pt_tree);

            	 ImageAttr(pt.Text, "height"); 

            	Match(input, Token.UP, null); adaptor.AddChild(root_0, root_1);_last = _save_last_1;
            	}


            }

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "heightText"

    public class widthText_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "widthText"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:71:1: widthText : ^( ATTR_WIDTH pt= WORD ) ;
    public WikiTree.widthText_return widthText() // throws RecognitionException [1]
    {   
        WikiTree.widthText_return retval = new WikiTree.widthText_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree pt = null;
        CommonTree ATTR_WIDTH45 = null;

        CommonTree pt_tree=null;
        CommonTree ATTR_WIDTH45_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:71:11: ( ^( ATTR_WIDTH pt= WORD ) )
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:71:13: ^( ATTR_WIDTH pt= WORD )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	_last = (CommonTree)input.LT(1);
            	{
            	CommonTree _save_last_1 = _last;
            	CommonTree _first_1 = null;
            	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
            	ATTR_WIDTH45=(CommonTree)Match(input,ATTR_WIDTH,FOLLOW_ATTR_WIDTH_in_widthText703); 
            		ATTR_WIDTH45_tree = (CommonTree)adaptor.DupNode(ATTR_WIDTH45);

            		root_1 = (CommonTree)adaptor.BecomeRoot(ATTR_WIDTH45_tree, root_1);



            	Match(input, Token.DOWN, null); 
            	_last = (CommonTree)input.LT(1);
            	pt=(CommonTree)Match(input,WORD,FOLLOW_WORD_in_widthText709); 
            		pt_tree = (CommonTree)adaptor.DupNode(pt);

            		adaptor.AddChild(root_1, pt_tree);

            	 ImageAttr(pt.Text, "width"); 

            	Match(input, Token.UP, null); adaptor.AddChild(root_0, root_1);_last = _save_last_1;
            	}


            }

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "widthText"

    public class floatText_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "floatText"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:73:1: floatText : ( ^( ATTR_FLOAT pt= WORD ) | ( ATTR_FLOAT ) ->);
    public WikiTree.floatText_return floatText() // throws RecognitionException [1]
    {   
        WikiTree.floatText_return retval = new WikiTree.floatText_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree pt = null;
        CommonTree ATTR_FLOAT46 = null;
        CommonTree ATTR_FLOAT47 = null;

        CommonTree pt_tree=null;
        CommonTree ATTR_FLOAT46_tree=null;
        CommonTree ATTR_FLOAT47_tree=null;
        RewriteRuleNodeStream stream_ATTR_FLOAT = new RewriteRuleNodeStream(adaptor,"token ATTR_FLOAT");

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:73:11: ( ^( ATTR_FLOAT pt= WORD ) | ( ATTR_FLOAT ) ->)
            int alt25 = 2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0 == ATTR_FLOAT) )
            {
                int LA25_1 = input.LA(2);

                if ( (LA25_1 == DOWN) )
                {
                    alt25 = 1;
                }
                else if ( (LA25_1 == UP || (LA25_1 >= ATTR_HEIGHT && LA25_1 <= ATTR_FLOAT)) )
                {
                    alt25 = 2;
                }
                else 
                {
                    NoViableAltException nvae_d25s1 =
                        new NoViableAltException("", 25, 1, input);

                    throw nvae_d25s1;
                }
            }
            else 
            {
                NoViableAltException nvae_d25s0 =
                    new NoViableAltException("", 25, 0, input);

                throw nvae_d25s0;
            }
            switch (alt25) 
            {
                case 1 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:73:13: ^( ATTR_FLOAT pt= WORD )
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	{
                    	CommonTree _save_last_1 = _last;
                    	CommonTree _first_1 = null;
                    	CommonTree root_1 = (CommonTree)adaptor.GetNilNode();_last = (CommonTree)input.LT(1);
                    	ATTR_FLOAT46=(CommonTree)Match(input,ATTR_FLOAT,FOLLOW_ATTR_FLOAT_in_floatText722); 
                    		ATTR_FLOAT46_tree = (CommonTree)adaptor.DupNode(ATTR_FLOAT46);

                    		root_1 = (CommonTree)adaptor.BecomeRoot(ATTR_FLOAT46_tree, root_1);



                    	Match(input, Token.DOWN, null); 
                    	_last = (CommonTree)input.LT(1);
                    	pt=(CommonTree)Match(input,WORD,FOLLOW_WORD_in_floatText728); 
                    		pt_tree = (CommonTree)adaptor.DupNode(pt);

                    		adaptor.AddChild(root_1, pt_tree);

                    	 ImageAttr(pt.Text, "float"); 

                    	Match(input, Token.UP, null); adaptor.AddChild(root_0, root_1);_last = _save_last_1;
                    	}


                    }
                    break;
                case 2 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:74:13: ( ATTR_FLOAT )
                    {
                    	// D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:74:13: ( ATTR_FLOAT )
                    	// D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:74:14: ATTR_FLOAT
                    	{
                    		_last = (CommonTree)input.LT(1);
                    		ATTR_FLOAT47=(CommonTree)Match(input,ATTR_FLOAT,FOLLOW_ATTR_FLOAT_in_floatText747);  
                    		stream_ATTR_FLOAT.Add(ATTR_FLOAT47);


                    	}



                    	// AST REWRITE
                    	// elements:          
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 74:27: ->
                    	{
                    	    root_0 = null;
                    	}

                    	retval.Tree = root_0;
                    }
                    break;

            }
            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "floatText"

    public class simpleText_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "simpleText"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:77:1: simpleText : ( alwaysText | txt= ( HTML_BASE | COMMENT | QUOTED | SYMBOLS | LT | GT | CSHARP_BASE | CSHARP_FLOW | CSHARP_SPECIAL | CSHARP_TYPES ) | whs= WS );
    public WikiTree.simpleText_return simpleText() // throws RecognitionException [1]
    {   
        WikiTree.simpleText_return retval = new WikiTree.simpleText_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree txt = null;
        CommonTree whs = null;
        WikiTree.alwaysText_return alwaysText48 = default(WikiTree.alwaysText_return);


        CommonTree txt_tree=null;
        CommonTree whs_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:77:15: ( alwaysText | txt= ( HTML_BASE | COMMENT | QUOTED | SYMBOLS | LT | GT | CSHARP_BASE | CSHARP_FLOW | CSHARP_SPECIAL | CSHARP_TYPES ) | whs= WS )
            int alt26 = 3;
            switch ( input.LA(1) ) 
            {
            case NEWLINE:
            case ESCAPE:
            case NOCONTROL:
            case STYLES:
            case COLORS:
            case ENCODED:
            case WORD:
            	{
                alt26 = 1;
                }
                break;
            case COMMENT:
            case QUOTED:
            case LT:
            case GT:
            case SYMBOLS:
            case CSHARP_BASE:
            case CSHARP_TYPES:
            case CSHARP_FLOW:
            case CSHARP_SPECIAL:
            case HTML_BASE:
            	{
                alt26 = 2;
                }
                break;
            case WS:
            	{
                alt26 = 3;
                }
                break;
            	default:
            	    NoViableAltException nvae_d26s0 =
            	        new NoViableAltException("", 26, 0, input);

            	    throw nvae_d26s0;
            }

            switch (alt26) 
            {
                case 1 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:77:17: alwaysText
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_alwaysText_in_simpleText763);
                    	alwaysText48 = alwaysText();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, alwaysText48.Tree);

                    }
                    break;
                case 2 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:78:15: txt= ( HTML_BASE | COMMENT | QUOTED | SYMBOLS | LT | GT | CSHARP_BASE | CSHARP_FLOW | CSHARP_SPECIAL | CSHARP_TYPES )
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	txt = (CommonTree)input.LT(1);
                    	if ( (input.LA(1) >= COMMENT && input.LA(1) <= QUOTED) || input.LA(1) == LT || input.LA(1) == GT || (input.LA(1) >= SYMBOLS && input.LA(1) <= HTML_BASE) ) 
                    	{
                    	    input.Consume();

                    	    txt_tree = (CommonTree)adaptor.DupNode(txt);

                    	    adaptor.AddChild(root_0, txt_tree);

                    	    state.errorRecovery = false;
                    	}
                    	else 
                    	{
                    	    MismatchedSetException mse = new MismatchedSetException(null,input);
                    	    throw mse;
                    	}

                    	 Append(txt); 

                    }
                    break;
                case 3 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:80:15: whs= WS
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	whs=(CommonTree)Match(input,WS,FOLLOW_WS_in_simpleText854); 
                    		whs_tree = (CommonTree)adaptor.DupNode(whs);

                    		adaptor.AddChild(root_0, whs_tree);

                    	 Append(" "); 

                    }
                    break;

            }
            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "simpleText"

    public class pureText_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "pureText"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:82:1: pureText : ( alwaysText | txt= ( HTML_BASE | COMMENT | QUOTED | SYMBOLS | LT | GT | CSHARP_BASE | CSHARP_FLOW | CSHARP_SPECIAL | CSHARP_TYPES ) | whs= WS );
    public WikiTree.pureText_return pureText() // throws RecognitionException [1]
    {   
        WikiTree.pureText_return retval = new WikiTree.pureText_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree txt = null;
        CommonTree whs = null;
        WikiTree.alwaysText_return alwaysText49 = default(WikiTree.alwaysText_return);


        CommonTree txt_tree=null;
        CommonTree whs_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:82:10: ( alwaysText | txt= ( HTML_BASE | COMMENT | QUOTED | SYMBOLS | LT | GT | CSHARP_BASE | CSHARP_FLOW | CSHARP_SPECIAL | CSHARP_TYPES ) | whs= WS )
            int alt27 = 3;
            switch ( input.LA(1) ) 
            {
            case NEWLINE:
            case ESCAPE:
            case NOCONTROL:
            case STYLES:
            case COLORS:
            case ENCODED:
            case WORD:
            	{
                alt27 = 1;
                }
                break;
            case COMMENT:
            case QUOTED:
            case LT:
            case GT:
            case SYMBOLS:
            case CSHARP_BASE:
            case CSHARP_TYPES:
            case CSHARP_FLOW:
            case CSHARP_SPECIAL:
            case HTML_BASE:
            	{
                alt27 = 2;
                }
                break;
            case WS:
            	{
                alt27 = 3;
                }
                break;
            	default:
            	    NoViableAltException nvae_d27s0 =
            	        new NoViableAltException("", 27, 0, input);

            	    throw nvae_d27s0;
            }

            switch (alt27) 
            {
                case 1 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:82:12: alwaysText
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_alwaysText_in_pureText870);
                    	alwaysText49 = alwaysText();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, alwaysText49.Tree);

                    }
                    break;
                case 2 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:83:15: txt= ( HTML_BASE | COMMENT | QUOTED | SYMBOLS | LT | GT | CSHARP_BASE | CSHARP_FLOW | CSHARP_SPECIAL | CSHARP_TYPES )
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	txt = (CommonTree)input.LT(1);
                    	if ( (input.LA(1) >= COMMENT && input.LA(1) <= QUOTED) || input.LA(1) == LT || input.LA(1) == GT || (input.LA(1) >= SYMBOLS && input.LA(1) <= HTML_BASE) ) 
                    	{
                    	    input.Consume();

                    	    txt_tree = (CommonTree)adaptor.DupNode(txt);

                    	    adaptor.AddChild(root_0, txt_tree);

                    	    state.errorRecovery = false;
                    	}
                    	else 
                    	{
                    	    MismatchedSetException mse = new MismatchedSetException(null,input);
                    	    throw mse;
                    	}

                    	 Append(txt); 

                    }
                    break;
                case 3 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:85:15: whs= WS
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	whs=(CommonTree)Match(input,WS,FOLLOW_WS_in_pureText961); 
                    		whs_tree = (CommonTree)adaptor.DupNode(whs);

                    		adaptor.AddChild(root_0, whs_tree);


                    }
                    break;

            }
            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "pureText"

    public class codeText_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "codeText"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:87:1: codeText : ( alwaysText | hb= HTML_BASE | cmt= COMMENT | qtd= QUOTED | s= ( SYMBOLS | LT | GT ) | csb= CSHARP_BASE | csf= CSHARP_FLOW | css= CSHARP_SPECIAL | cst= CSHARP_TYPES | whs= WS );
    public WikiTree.codeText_return codeText() // throws RecognitionException [1]
    {   
        WikiTree.codeText_return retval = new WikiTree.codeText_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree hb = null;
        CommonTree cmt = null;
        CommonTree qtd = null;
        CommonTree s = null;
        CommonTree csb = null;
        CommonTree csf = null;
        CommonTree css = null;
        CommonTree cst = null;
        CommonTree whs = null;
        WikiTree.alwaysText_return alwaysText50 = default(WikiTree.alwaysText_return);


        CommonTree hb_tree=null;
        CommonTree cmt_tree=null;
        CommonTree qtd_tree=null;
        CommonTree s_tree=null;
        CommonTree csb_tree=null;
        CommonTree csf_tree=null;
        CommonTree css_tree=null;
        CommonTree cst_tree=null;
        CommonTree whs_tree=null;

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:87:13: ( alwaysText | hb= HTML_BASE | cmt= COMMENT | qtd= QUOTED | s= ( SYMBOLS | LT | GT ) | csb= CSHARP_BASE | csf= CSHARP_FLOW | css= CSHARP_SPECIAL | cst= CSHARP_TYPES | whs= WS )
            int alt28 = 10;
            switch ( input.LA(1) ) 
            {
            case NEWLINE:
            case ESCAPE:
            case NOCONTROL:
            case STYLES:
            case COLORS:
            case ENCODED:
            case WORD:
            	{
                alt28 = 1;
                }
                break;
            case HTML_BASE:
            	{
                alt28 = 2;
                }
                break;
            case COMMENT:
            	{
                alt28 = 3;
                }
                break;
            case QUOTED:
            	{
                alt28 = 4;
                }
                break;
            case LT:
            case GT:
            case SYMBOLS:
            	{
                alt28 = 5;
                }
                break;
            case CSHARP_BASE:
            	{
                alt28 = 6;
                }
                break;
            case CSHARP_FLOW:
            	{
                alt28 = 7;
                }
                break;
            case CSHARP_SPECIAL:
            	{
                alt28 = 8;
                }
                break;
            case CSHARP_TYPES:
            	{
                alt28 = 9;
                }
                break;
            case WS:
            	{
                alt28 = 10;
                }
                break;
            	default:
            	    NoViableAltException nvae_d28s0 =
            	        new NoViableAltException("", 28, 0, input);

            	    throw nvae_d28s0;
            }

            switch (alt28) 
            {
                case 1 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:87:15: alwaysText
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	PushFollow(FOLLOW_alwaysText_in_codeText972);
                    	alwaysText50 = alwaysText();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, alwaysText50.Tree);

                    }
                    break;
                case 2 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:88:16: hb= HTML_BASE
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	hb=(CommonTree)Match(input,HTML_BASE,FOLLOW_HTML_BASE_in_codeText991); 
                    		hb_tree = (CommonTree)adaptor.DupNode(hb);

                    		adaptor.AddChild(root_0, hb_tree);

                    	 SpanClassTag(hb.Text , "html");

                    }
                    break;
                case 3 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:89:15: cmt= COMMENT
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	cmt=(CommonTree)Match(input,COMMENT,FOLLOW_COMMENT_in_codeText1015); 
                    		cmt_tree = (CommonTree)adaptor.DupNode(cmt);

                    		adaptor.AddChild(root_0, cmt_tree);

                    	 SpanClassTag(cmt.Text, "cmmnt");

                    }
                    break;
                case 4 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:90:15: qtd= QUOTED
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	qtd=(CommonTree)Match(input,QUOTED,FOLLOW_QUOTED_in_codeText1041); 
                    		qtd_tree = (CommonTree)adaptor.DupNode(qtd);

                    		adaptor.AddChild(root_0, qtd_tree);

                    	 SpanClassTag(qtd.Text, "qtd");  

                    }
                    break;
                case 5 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:91:17: s= ( SYMBOLS | LT | GT )
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	s = (CommonTree)input.LT(1);
                    	if ( input.LA(1) == LT || input.LA(1) == GT || input.LA(1) == SYMBOLS ) 
                    	{
                    	    input.Consume();

                    	    s_tree = (CommonTree)adaptor.DupNode(s);

                    	    adaptor.AddChild(root_0, s_tree);

                    	    state.errorRecovery = false;
                    	}
                    	else 
                    	{
                    	    MismatchedSetException mse = new MismatchedSetException(null,input);
                    	    throw mse;
                    	}

                    	 SpanClassTag(s.Text, "smbl"); 

                    }
                    break;
                case 6 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:92:15: csb= CSHARP_BASE
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	csb=(CommonTree)Match(input,CSHARP_BASE,FOLLOW_CSHARP_BASE_in_codeText1100); 
                    		csb_tree = (CommonTree)adaptor.DupNode(csb);

                    		adaptor.AddChild(root_0, csb_tree);

                    	 SpanClassTag(csb.Text, "base"); 

                    }
                    break;
                case 7 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:93:15: csf= CSHARP_FLOW
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	csf=(CommonTree)Match(input,CSHARP_FLOW,FOLLOW_CSHARP_FLOW_in_codeText1122); 
                    		csf_tree = (CommonTree)adaptor.DupNode(csf);

                    		adaptor.AddChild(root_0, csf_tree);

                    	 SpanClassTag(csf.Text, "flw"); 

                    }
                    break;
                case 8 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:94:15: css= CSHARP_SPECIAL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	css=(CommonTree)Match(input,CSHARP_SPECIAL,FOLLOW_CSHARP_SPECIAL_in_codeText1144); 
                    		css_tree = (CommonTree)adaptor.DupNode(css);

                    		adaptor.AddChild(root_0, css_tree);

                    	 SpanClassTag(css.Text, "spcl"); 

                    }
                    break;
                case 9 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:95:15: cst= CSHARP_TYPES
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	cst=(CommonTree)Match(input,CSHARP_TYPES,FOLLOW_CSHARP_TYPES_in_codeText1163); 
                    		cst_tree = (CommonTree)adaptor.DupNode(cst);

                    		adaptor.AddChild(root_0, cst_tree);

                    	 SpanClassTag(cst.Text, "type"); 

                    }
                    break;
                case 10 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:96:15: whs= WS
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	whs=(CommonTree)Match(input,WS,FOLLOW_WS_in_codeText1184); 
                    		whs_tree = (CommonTree)adaptor.DupNode(whs);

                    		adaptor.AddChild(root_0, whs_tree);

                    	 Append(WhiteSpaceText(whs.Text)); 

                    }
                    break;

            }
            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "codeText"

    public class alwaysText_return : TreeRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "alwaysText"
    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:99:1: alwaysText : (txt= ( WORD | NOCONTROL | ENCODED | COLORS | STYLES ) | esc= ESCAPE | NEWLINE ->);
    public WikiTree.alwaysText_return alwaysText() // throws RecognitionException [1]
    {   
        WikiTree.alwaysText_return retval = new WikiTree.alwaysText_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree txt = null;
        CommonTree esc = null;
        CommonTree NEWLINE51 = null;

        CommonTree txt_tree=null;
        CommonTree esc_tree=null;
        CommonTree NEWLINE51_tree=null;
        RewriteRuleNodeStream stream_NEWLINE = new RewriteRuleNodeStream(adaptor,"token NEWLINE");

        try 
    	{
            // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:99:14: (txt= ( WORD | NOCONTROL | ENCODED | COLORS | STYLES ) | esc= ESCAPE | NEWLINE ->)
            int alt29 = 3;
            switch ( input.LA(1) ) 
            {
            case NOCONTROL:
            case STYLES:
            case COLORS:
            case ENCODED:
            case WORD:
            	{
                alt29 = 1;
                }
                break;
            case ESCAPE:
            	{
                alt29 = 2;
                }
                break;
            case NEWLINE:
            	{
                alt29 = 3;
                }
                break;
            	default:
            	    NoViableAltException nvae_d29s0 =
            	        new NoViableAltException("", 29, 0, input);

            	    throw nvae_d29s0;
            }

            switch (alt29) 
            {
                case 1 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:99:17: txt= ( WORD | NOCONTROL | ENCODED | COLORS | STYLES )
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	txt = (CommonTree)input.LT(1);
                    	if ( input.LA(1) == NOCONTROL || (input.LA(1) >= STYLES && input.LA(1) <= COLORS) || input.LA(1) == ENCODED || input.LA(1) == WORD ) 
                    	{
                    	    input.Consume();

                    	    txt_tree = (CommonTree)adaptor.DupNode(txt);

                    	    adaptor.AddChild(root_0, txt_tree);

                    	    state.errorRecovery = false;
                    	}
                    	else 
                    	{
                    	    MismatchedSetException mse = new MismatchedSetException(null,input);
                    	    throw mse;
                    	}

                    	 Append(txt); 

                    }
                    break;
                case 2 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:100:16: esc= ESCAPE
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	_last = (CommonTree)input.LT(1);
                    	esc=(CommonTree)Match(input,ESCAPE,FOLLOW_ESCAPE_in_alwaysText1246); 
                    		esc_tree = (CommonTree)adaptor.DupNode(esc);

                    		adaptor.AddChild(root_0, esc_tree);

                    	 Append(EscapedText(esc.Text)); 

                    }
                    break;
                case 3 :
                    // D:\\Workspace\\Projects2010\\Wiki\\WikiNetParser\\ProjectBase.Tools\\Wiki\\WikiTree.g:101:16: NEWLINE
                    {
                    	_last = (CommonTree)input.LT(1);
                    	NEWLINE51=(CommonTree)Match(input,NEWLINE,FOLLOW_NEWLINE_in_alwaysText1267);  
                    	stream_NEWLINE.Add(NEWLINE51);



                    	// AST REWRITE
                    	// elements:          
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 101:24: ->
                    	{
                    	    root_0 = null;
                    	}

                    	retval.Tree = root_0;
                    }
                    break;

            }
            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "alwaysText"

    // Delegated rules


	private void InitializeCyclicDFAs()
	{
	}

 

    public static readonly BitSet FOLLOW_statement_in_execute56 = new BitSet(new ulong[]{0x0000000000040002UL,0x0000000000006710UL});
    public static readonly BitSet FOLLOW_block_in_statement64 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_lists_in_statement68 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NEWLINE_in_statement72 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ELEMENT_in_block90 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_element_in_block95 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x0000000000007FFBUL});
    public static readonly BitSet FOLLOW_CODE_in_block120 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_element_in_block127 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x0000000000007FFBUL});
    public static readonly BitSet FOLLOW_HTML_in_block153 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_element_in_block160 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x0000000000007FFBUL});
    public static readonly BitSet FOLLOW_XML_in_block186 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_element_in_block194 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x0000000000007FFBUL});
    public static readonly BitSet FOLLOW_LIST_in_lists218 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_NEWLINE_in_lists225 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x0000000000007FFBUL});
    public static readonly BitSet FOLLOW_listItem_in_lists229 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x0000000000007FFBUL});
    public static readonly BitSet FOLLOW_NEWLINE_in_lists233 = new BitSet(new ulong[]{0x0000000000040008UL});
    public static readonly BitSet FOLLOW_NUMERIC_in_lists256 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_NEWLINE_in_lists260 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x0000000000007FFBUL});
    public static readonly BitSet FOLLOW_listItem_in_lists264 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x0000000000007FFBUL});
    public static readonly BitSet FOLLOW_NEWLINE_in_lists268 = new BitSet(new ulong[]{0x0000000000040008UL});
    public static readonly BitSet FOLLOW_element_in_listItem303 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_block_in_element332 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_lists_in_element336 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_atom_in_element340 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_codeText_in_element344 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_tag_in_element348 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_atom_in_inlineElement355 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_codeText_in_inlineElement359 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_tag_in_inlineElement363 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_inline_in_atom374 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_anchor_in_atom378 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_name_in_atom382 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_image_in_atom386 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_INLINE_in_inline403 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_inlineElement_in_inline428 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x0000000000007FFBUL});
    public static readonly BitSet FOLLOW_A_ELEMENT_in_anchor467 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_pureText_in_anchor474 = new BitSet(new ulong[]{0xF800018C0D3C0000UL,0x000000000000000BUL});
    public static readonly BitSet FOLLOW_attrText_in_anchor504 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_NAME_ELEMENT_in_name533 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_pureText_in_name537 = new BitSet(new ulong[]{0xF800018C0D3C0008UL,0x000000000000000BUL});
    public static readonly BitSet FOLLOW_IMG_ELEMENT_in_image568 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_pureText_in_image573 = new BitSet(new ulong[]{0xF80001FC0D3C0008UL,0x000000000000000BUL});
    public static readonly BitSet FOLLOW_heightText_in_image604 = new BitSet(new ulong[]{0x0000007000000008UL});
    public static readonly BitSet FOLLOW_widthText_in_image608 = new BitSet(new ulong[]{0x0000007000000008UL});
    public static readonly BitSet FOLLOW_floatText_in_image612 = new BitSet(new ulong[]{0x0000007000000008UL});
    public static readonly BitSet FOLLOW_TAG_in_tag646 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_codeText_in_tag651 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x000000000000000BUL});
    public static readonly BitSet FOLLOW_ATTR_TEXT_in_attrText667 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_simpleText_in_attrText670 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x00000000000008EBUL});
    public static readonly BitSet FOLLOW_image_in_attrText674 = new BitSet(new ulong[]{0xF80001840D3C0008UL,0x00000000000008EBUL});
    public static readonly BitSet FOLLOW_ATTR_HEIGHT_in_heightText686 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_WORD_in_heightText690 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_ATTR_WIDTH_in_widthText703 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_WORD_in_widthText709 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_ATTR_FLOAT_in_floatText722 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_WORD_in_floatText728 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_ATTR_FLOAT_in_floatText747 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_alwaysText_in_simpleText763 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_simpleText781 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WS_in_simpleText854 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_alwaysText_in_pureText870 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_pureText888 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WS_in_pureText961 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_alwaysText_in_codeText972 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_HTML_BASE_in_codeText991 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_COMMENT_in_codeText1015 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_QUOTED_in_codeText1041 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_codeText1070 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CSHARP_BASE_in_codeText1100 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CSHARP_FLOW_in_codeText1122 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CSHARP_SPECIAL_in_codeText1144 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CSHARP_TYPES_in_codeText1163 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WS_in_codeText1184 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_alwaysText1206 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ESCAPE_in_alwaysText1246 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NEWLINE_in_alwaysText1267 = new BitSet(new ulong[]{0x0000000000000002UL});

}
}